{
  LW Meshedt -- LightWave MeshDataEdit Server

  This header contains the types and declarations for the Modeler
  MeshDataEdit class.

  Based on lwmeshedt.h which is:
  Copyright 1999, NewTek, Inc.
}

{
  Copyright 2012, Jameel Halabi

  This unit is part of the BlaiseWave wrapper,
  which is licensed under the BSD 2-Clause license (see licenses/license.txt).
}

unit LW_Meshedt;

{$mode objfpc}{$H+}

interface

uses
  LW_Types   ,
  LW_Modeler ,
  LW_Meshes  ,
  LW_PointGenerator,
  LW_EdgeGenerator ,
  LW_PolyGenerator;

const
  LWMESHEDIT_CLASS    = 'MeshDataEdit' ;

  LWMESHEDIT_VERSION  = 6 ;

  EDDF_SELECT    = 1 shl 0 ;
  EDDF_DELETE    = 1 shl 1 ;
  EDPF_CCEND     = 1 shl 2 ;
  EDPF_CCSTART   = 1 shl 3 ;

  EDERR_NONE       = 0 ;
  EDERR_NOMEMORY   = 1 ;
  EDERR_BADLAYER   = 2 ;
  EDERR_BADSURF    = 3 ;
  EDERR_USERABORT  = 4 ;
  EDERR_BADARGS    = 5 ;
  EDERR_BADVMAP    = 6 ;

  EDSELM_CLEARCURRENT = 1 shl 0 ;
  EDSELM_SELECTNEW    = 1 shl 1 ;
  EDSELM_FORCEVRTS    = 1 shl 2 ;
  EDSELM_FORCEPOLS    = 1 shl 3 ;

  OPSEL_MODIFY        = 1 shl 15 ;

  EDCOUNT_ALL         = 0 ;
  EDCOUNT_SELECT      = 1 ;
  EDCOUNT_DELETE      = 2 ;

type
  PMeshEditState = record end;
  TEDStateRef = PMeshEditState;

  PEDPointInfo = ^TEDPointInfo;
  TEDPointInfo = record
    PointID   : PLWPnt  ;
    UserData  : Pointer ;
    Layer     : Integer ;
    Flags     : Integer ;

    Position  : Array[0..2] of Double;
    VmapVec   : PSingle              ;

    NumEdges  : Integer ;
    Edges     : PLWEdge ; // const
  end;

  PEDPolygonInfo = ^TEDPolygonInfo;
  TEDPolygonInfo = record
    PolID     : PLWPol;
    UserData  : Pointer ;
    Layer     : Integer ;
    Flags     : Integer ;

    NumPnts   : Integer ;
    Points    : PLWPnt  ; // const

    Surface   : PChar   ; // const
    Type_     : UInt32 ;
    TypeFlags : Integer ;
  end;

  PEDEdgeInfo = ^TEDEdgeInfo;
  TEDEdgeInfo = record
    EdgeID    : PLWEdge ;
    UserData  : Pointer ;
    Layer     : Integer ;
    Flags     : Integer ;

    P1, P2    : PLWPnt  ;

    NumPols   : Integer ;
    Pols      : PLWPol  ; // const
  end;

  TEDError = Integer ;

  TEDPointScanFunc       = function
                           (      UserData  : Pointer        ;
                            const PointInfo : PEDPointInfo   ) : TEDError ;

  TEDEdgeScanFunc        = function
                           (      UserData  : Pointer        ;
                            const EdgeInfo  : PEDEdgeInfo    ) : TEDError ;

  TEDPolyScanFunc        = function
                           (      UserData  : Pointer        ;
                            const PolyInfo  : PEDPolygonInfo ) : TEDError ;

  TEDFastPointScanFunc   = function
                           (      UserData  : Pointer        ;
                                  PointID   : PLWPnt         ) : TEDError ;

  TEDFastEdgeScanFunc    = function
                           (      UserData  : Pointer        ;
                                  EdgeID    : PLWEdge        ) : TEDError ;

  TEDFastPolyScanFunc     = function
                           (      UserData  : Pointer        ;
                                  PolygonID : PLWPol         ) : TEDError ;

  PEDBoundCv = ^TEDBoundCv;
  TEDBoundCv = record
    Curve   : PLWPol    ;
    Start               ,
    End_    : Integer   ;
  end;

  PMeshEditOp = ^TMeshEditOp;
  TMeshEditOp = record
    State      : TEDStateRef                    ;
    LayerNum   : Integer                        ;

    Done       : procedure
                 (      State    : TEDStateRef  ;
                        Error    : TEDError      ;
                        Selset   : Integer      ) ;

    PointCount : function
                 (      State    : TEDStateRef  ;
                        OpLayer  : TEltOpLayer  ;
                        Mode     : Integer      ) : Integer ;
    PolyCount  : function
                 (      State    : TEDStateRef  ;
                        OpLayer  : TEltOpLayer  ;
                        Mode     : Integer      ) : Integer ;

    PointScan  : function
                 (      State    : TEDStateRef      ;
                        ScanFunc : TEDPointScanFunc ;
                        UserData : Pointer          ;
                        OpLayer  : TEltOpLayer      ) : TEDError ;
    PolyScan   : function
                 (      State    : TEDStateRef      ;
                        ScanFunc : TEDPolyScanFunc  ;
                        UserData : Pointer          ;
                        OpLayer  : TEltOpLayer      ) : TEDError ;

    PointInfo  : function
                 (      State    : TEDStateRef      ;
                        PointID  : PLWPnt           ) : PEDPointInfo    ;
    PolyInfo   : function
                 (      State     : TEDStateRef      ;
                        PolygonID : PLWPol           ) : PEDPolygonInfo  ;

    PolyNormal : function
                 (      State     : TEDStateRef      ;
                        PolygonID : PLWPol           ;
                        Norm      : Array {[0..2]} of Double ) : Integer ;

    AddPoint   : function
                 (      State    : TEDStateRef      ;
                        XYZ      : PDouble          ) : PLWPnt    ;
    AddFace    : function
                 (      State      : TEDStateRef      ;
                  const Surf       : PChar            ;
                        NumPnt     : Integer          ;
                  const PointArray : PLWPnt           ) : PLWPol  ;
    AddCurve   : function
                 (      State      : TEDStateRef      ;
                  const Surf       : PChar            ;
                        NumPnt     : Integer          ;
                  const PointArray : PLWPnt           ;
                        Flags      : Integer          ) : PLWPol  ;
    AddQuad    : function
                 (      State      : TEDStateRef      ;
                        V1                            ,
                        V2                            ,
                        V3                            ,
                        V4         : PLWPnt           ) : TEDError ;
    AddTri     : function
                 (      State      : TEDStateRef      ;
                        V1                            ,
                        V2                            ,
                        V3         : PLWPnt           ) : TEDError ;
    AddPatch   : function
                 (      State      : TEDStateRef      ;
                        NR                            ,
                        NC                            ,
                        LR                            ,
                        LC         : Integer          ;
                        R0                            ,
                        R1                            ,
                        C0                            ,
                        C1         : PEDBoundCv       ) : TEDError ;

    RemPoint   : function
                 (      State      : TEDStateRef      ;
                        PointID    : PLWPnt           ) : TEDError ;
    RemPoly    : function
                 (      State      : TEDStateRef      ;
                        PolygonID  : PLWPol           ) : TEDError ;

    PntMove    : function
                 (      State      : TEDStateRef      ;
                        PointID    : PLWPnt           ;
                  const Pos        : PDouble          ) : TEDError ;
    PolSurf    : function
                 (      State      : TEDStateRef      ;
                        PolygonID  : PLWPol           ;
                  const SurfName   : PChar            ) : TEDError ;
    PolPnts    : function
                 (      State      : TEDStateRef      ;
                        PolygonID  : PLWPol           ;
                        NPoints    : Integer          ;
                  const PointArray : PLWPnt           ) : TEDError ;
    PolFlag    : function
                 (      State      : TEDStateRef      ;
                        PolygonID  : PLWPol           ;
                        Mask                          ,
                        Value      : Integer          ) : TEDError ;
    PolTag     : function
                 (      State      : TEDStateRef      ;
                        PolygonID  : PLWPol           ;
                        Tagtype    : TLWID            ;
                  const Tag        : PChar            ) : TEDError ;
    PntVMap    : function
                 (      State      : TEDStateRef      ;
                        PointID    : PLWPnt           ;
                        Type_      : TLWID            ;
                  const Name       : PChar            ;
                        NValues    : Integer          ;
                        ValArray   : PSingle          ) : TEDError ;

    AddPoly    : function
                 (      State      : TEDStateRef      ;
                        Type_      : TLWID            ;
                        Template   : PLWPol           ;
                  const surf       : PChar            ;
                        NumPnt     : Integer          ;
                  const PointArray : PLWPnt           ) : PLWPol  ;
    AddIPnt    : function
                 (      State      : TEDStateRef      ;
                        XYZ        : PDouble          ;
                        NumPnt     : Integer          ;
                  const PointArray : PLWPnt           ;
                  const WT         : PDouble          ) : PLWPnt  ;
    InitUV     : function
                 (      State      : TEDStateRef      ;
                        UV         : PSingle          ) : TEDError ;

    PointVSet  : function
                 (      State      : TEDStateRef      ;
                        VmapID     : Pointer          ;
                        VmapType   : TLWID            ;
                  const VmapName   : PChar            ) : Pointer;
    PointVGet  : function
                 (      State      : TEDStateRef      ;
                        PointID    : PLWPnt           ;
                        VMapVector : PSingle          ) : Integer ;
    PolyTag    : function
                 (      State      : TEDStateRef      ;
                        PolygonID  : PLWPol           ;
                        TagType    : TLWID            ) : PChar ; // const

    PntSelect  : function
                 (      State          : TEDStateRef  ;
                        PointID        : PLWPnt       ;
                        SelectionState : Integer      ) : TEDError;
    PolSelect  : function
                 (      State          : TEDStateRef  ;
                        PolygonID      : PLWPol       ;
                        SelectionState : Integer      ) : TEDError;

    PointVPGet : function
                 (      State          : TEDStateRef  ;
                        PointID        : PLWPnt       ;
                        PolygonID      : PLWPol       ;
                        VMapVector     : PSingle      ) : Integer ;
    PointVEval : function
                 (      State          : TEDStateRef  ;
                        PointID        : PLWPnt       ;
                        PolygonID      : PLWPol       ;
                        VMapVector     : PSingle      ) : Integer ;
    PntVPMap   : function
                 (      State          : TEDStateRef  ;
                        PointID        : PLWPnt       ;
                        PolygonID      : PLWPol       ;
                        VmapType       : TLWID        ;
                  const VmapName       : PChar        ;
                        VMapDimensions : Integer      ;
                        VMapVector     : PSingle      ) : TEDError;

    // New in Lightwave 9.0 - LWMESHEDIT_VERSION 5
    EdgeCount  : function
                 (      State          : TEDStateRef  ;
                        OpLayer        : TEltOpLayer  ;
                        Mode           : Integer      ) : Integer ;
    EdgeScan   : function
                 (      State          : TEDStateRef     ;
                        ScanFunc       : TEDEdgeScanFunc ;
                        UserData       : Pointer         ;
                        OpLayer        : TEltOpLayer     ) : TEDError ;
    EdgeInfo   : function
                 (      State          : TEDStateRef     ;
                        EdgeID         : PLWEdge         ) : TEDEdgeInfo ;
    EdgeSelect : function
                 (      State          : TEDStateRef     ;
                        EdgeID         : PLWEdge         ;
                        SelectionState : Integer         ) : TEDError;
    EdgePolys  : function
                 (      State          : TEDStateRef     ;
                        EdgeID         : PLWEdge         ;
                  const OutPolygons    : PPPLWPol        ) : Integer ;
    EdgePoint1 : function
                 (      State          : TEDStateRef     ;
                        EdgeID         : PLWEdge         ) : PLWPnt;
    EdgePoint2 : function
                 (      State          : TEDStateRef     ;
                        EdgeID         : PLWEdge         ) : PLWPnt;
    EdgeFromPoints : function
                     (  State          : TEDStateRef     ;
                        PointID        : PLWPnt          ) : PLWEdge;
    EdgeFlip   : procedure
                 (      State          : TEDStateRef     ;
                        EdgeID         : PLWEdge         ) ;

    PointPos   : procedure
                 (      State          : TEDStateRef     ;
                        PointID        : PLWPnt          ;
                        OutPosition    : array {[0..2]} of Double ) ;
    PointEdges : function
                 (      State          : TEDStateRef    ;
                        PointID        : PLWPnt         ;
                  const EdgeID         : PPPLWEdge ) : Integer ;

    PolyType   : function
                 (      State          : TEDStateRef    ;
                        PolygonID      : PLWPol         ) : UInt32 ;
    PolyPoints : function
                 (      State          : TEDStateRef    ;
                        PolygonID      : PLWPol         ;
                  const PointID        : PPLWPnt        ) : Integer ;

    PointFlags : function
                 (      State          : TEDStateRef    ;
                        PointID        : PLWPnt         ) : Integer ;
    EdgeFlags  : function
                 (      State          : TEDStateRef    ;
                        EdgeID         : PLWEdge        ) : Integer ;
    PolyFlags  : function
                 (      State          : TEDStateRef    ;
                        PolygonID      : PLWPol         ) : Integer ;

    PointData  : function
                 (      State          : TEDStateRef    ;
                        PointID        : PLWPnt         ) : Pointer;
    EdgeData   : function
                 (      State          : TEDStateRef    ;
                        EdgeID         : PLWEdge        ) : Pointer;
    PolyData   : function
                 (      State          : TEDStateRef    ;
                        PolygonID      : PLWPol         ) : Pointer ;

    FastPointScan : function
                    (   State          : TEDStateRef    ;
                        ScanFunc       : TEDFastPointScanFunc;
                        UserData       : Pointer              ;
                        OpLayer        : TEltOpLayer          ;
                        SelectedOnly   : Integer              ) : TEDError;
    FastEdgeScan : function
                   (    State          : TEDStateRef          ;
                        ScanFunc       : TEDFastEdgeScanFunc  ;
                        UserData       : Pointer              ;
                        OpLayer        : TEltOpLayer          ;
                        SelectedOnly    : Integer             ) : TEDError;
    FastPolyScan : function
                   (    State          : TEDStateRef          ;
                        ScanFunc       : TEDFastPolyScanFunc  ;
                        UserData       : Pointer              ;
                        OpLayer        : TEltOpLayer          ;
                        SelectedOnly   : Integer             ) : TEDError;

    PointLayer : function
                 (      State           : TEDStateRef         ;
                        PointID         : PLWPnt              ) : Integer ;
    EdgeLayer  : function
                 (      State           : TEDStateRef         ;
                        EdgeID          : PLWEdge             ) : Integer ;
    PolyLayer  : function
                 (      State           : TEDStateRef         ;
                        PolygonID       : PLWPol              ) : Integer ;

    SetLayer   : function
                 (      State           : TEDStateRef         ;
                        LayerNum        : Integer             ) : Integer ;
    AdvanceLayer : function
                   (    State           : TEDStateRef         ) : Integer ;

    PointNew   : function
                 (      State           : TEDStateRef         ;
                        PointID         : PLWPnt              ) : Integer ;
    EdgeNew    : function
                 (      State           : TEDStateRef         ;
                        EdgeID          : PLWEdge             ) : Integer ;
    PolyNew    : function
                 (      State           : TEDStateRef         ;
                        PolygonID       : PLWPol              ) : Integer ;

    GenPoints  : function
                 (      State           : TEDStateRef         ;
                        OpLayer         : TEltOpLayer         ;
                        SelectedOnly    : Integer             ) : PLWPointGenerator ;
    GenEdges   : function
                 (      State           : TEDStateRef         ;
                        OpLayer         : TEltOpLayer         ;
                        SelectedOnly    : Integer             ) : PLWEdgeGenerator ;
    GenPolys   : function
                 (      State           : TEDStateRef         ;
                        OpLayer         : TEltOpLayer         ;
                        SelectedOnly    : Integer             ) : PLWPolyGenerator;

    // new in Lightwave 9.6 - LWMESHEDIT_VERSION 6
    VMapSelect : function
                 (      State           : TEDStateRef         ;
                  const Name            : PChar               ;
                        Type_           : TLWID               ;
                        Dim             : Integer             ) : Pointer;
    VMapExists : function
                 (      State           : TEDStateRef         ;
                  const Name            : PChar               ;
                        Type_           : TLWID               ) : Integer ;
    VMapGetDimension : function
                 (      State           : TEDStateRef         ) : UInt32 ;
    VMapSet    : procedure
                 (      State           : TEDStateRef         ;
                        PointID         : PLWPnt              ;
                        PolygonID       : PLWPol              ;
                  const Value           : PSingle             );
    VMapSetIdeal : procedure
                 (      State           : TEDStateRef         ;
                        PointID         : PLWPnt              ;
                        PolygonID       : PLWPol              ;
                  const Value           : PSingle             );
    VMapRename : procedure
                 (      State           : TEDStateRef         ;
                  const NewName         : PChar               );
    VMapRemove : procedure
                 (      State           : TEDStateRef         ) ;
  end;

  // Required for backward compatability
  TMeshEditBegin = function
                   (      PntBuf                       ,
                          PolBuf        : Integer      ;
                          Selection     : TEltOpSelect ) : PMeshEditOp;

  // newer, alternative function with edge buffer allocation
  TMeshEditBegin2 = function
                    (      PntBuf                     ,
                           EdgeBuf                    ,
                           PolBuf       : Integer     ;
                           Selection    : TEltOpSelect ) : PMeshEditOp;

implementation

end.

